package top.glike;

import top.glike.config.SSLConfig;
import top.glike.model.SSLCertificate;
import top.glike.service.SSLCertificateService;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.FileUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * SSL证书自动管理工具
 * 功能：
 * 1. 监控SSL证书到期情况
 * 2. 自动申请即将到期的证书
 * 3. 自动下载nginx格式的证书文件
 */
public class Main {
    
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    private static final String DEFAULT_CONFIG_FILE = "ssl-config.json";
    
    public static void main(String[] args) {
        try {
            logger.info("=== SSL证书自动管理工具启动 ===");
            
            // 解析命令行参数
            String configFile = parseConfigFile(args);
            String action = parseAction(args);
            
            // 检查配置文件
            if (!FileUtil.exist(configFile)) {
                logger.info("配置文件不存在，生成默认配置文件: {}", configFile);
                SSLConfig.generateDefaultConfig(configFile);
                logger.info("请编辑配置文件后重新运行程序");
                return;
            }
            
            // 加载配置
            SSLConfig config = SSLConfig.loadFromFile(configFile);
            logger.info("配置文件加载成功: {}", configFile);
            logger.info("配置文件加载成功: {}", config);

            // 创建SSL证书服务
            SSLCertificateService sslService = new SSLCertificateService(config);
            
            // 根据动作执行相应功能
            switch (action.toLowerCase()) {
                case "check":
                    checkCertificates(sslService);
                    break;
                case "check-expired":
                    checkExpiredCertificates(sslService);
                    break;
                case "check-all":
                    checkAllCertificatesStatus(sslService);
                    break;
                case "auto":
                    autoRenewCertificates(sslService);
                    break;
                case "list":
                    listAllCertificates(sslService);
                    break;
                case "help":
                    printHelp();
                    break;
                default:
                    logger.info("未指定操作，执行默认的证书检查和自动续期");
                    autoRenewCertificates(sslService);
                    break;
            }
            
            logger.info("=== SSL证书管理工具执行完成 ===");
            
        } catch (Exception e) {
            logger.error("程序执行失败: " + e.getMessage(), e);
            System.exit(1);
        }
    }
    
    /**
     * 解析配置文件路径
     */
    private static String parseConfigFile(String[] args) {
        for (int i = 0; i < args.length - 1; i++) {
            if ("-c".equals(args[i]) || "--config".equals(args[i])) {
                return args[i + 1];
            }
        }
        return DEFAULT_CONFIG_FILE;
    }
    
    /**
     * 解析操作类型
     */
    private static String parseAction(String[] args) {
        for (int i = 0; i < args.length - 1; i++) {
            if ("-a".equals(args[i]) || "--action".equals(args[i])) {
                return args[i + 1];
            }
        }
        
        // 检查是否有直接的操作参数
        for (String arg : args) {
            if (arg.equals("check") || arg.equals("check-expired") || arg.equals("check-all") ||
                arg.equals("auto") || arg.equals("list") || arg.equals("help")) {
                return arg;
            }
        }
        
        return "auto";
    }
    
    /**
     * 检查证书到期情况（仅即将到期）
     */
    private static void checkCertificates(SSLCertificateService sslService) {
        logger.info("开始检查即将到期的证书...");
        
        List<SSLCertificate> expiringCerts = sslService.checkExpiringCertificates();
        
        if (CollUtil.isEmpty(expiringCerts)) {
            logger.info("没有发现即将到期的证书");
        } else {
            logger.warn("发现{}个即将到期的证书:", expiringCerts.size());
            for (SSLCertificate cert : expiringCerts) {
                logger.warn("  - {}", cert);
            }
        }
    }
    
    /**
     * 检查已过期的证书
     */
    private static void checkExpiredCertificates(SSLCertificateService sslService) {
        logger.info("开始检查已过期的证书...");
        
        List<SSLCertificate> expiredCerts = sslService.checkExpiredCertificates();
        
        if (CollUtil.isEmpty(expiredCerts)) {
            logger.info("没有发现已过期的证书");
        } else {
            logger.error("发现{}个已过期的证书:", expiredCerts.size());
            for (SSLCertificate cert : expiredCerts) {
                logger.error("  - {}", cert);
            }
        }
    }
    
    /**
     * 检查所有证书状态（包括即将过期和已过期）
     */
    private static void checkAllCertificatesStatus(SSLCertificateService sslService) {
        logger.info("开始检查所有证书状态...");
        
        // 检查即将到期的证书
        List<SSLCertificate> expiringCerts = sslService.checkExpiringCertificates();
        if (!CollUtil.isEmpty(expiringCerts)) {
            logger.warn("发现{}个即将到期的证书:", expiringCerts.size());
            for (SSLCertificate cert : expiringCerts) {
                logger.warn("  - [即将过期] {}", cert);
            }
        }
        
        // 检查已过期的证书
        List<SSLCertificate> expiredCerts = sslService.checkExpiredCertificates();
        if (!CollUtil.isEmpty(expiredCerts)) {
            logger.error("发现{}个已过期的证书:", expiredCerts.size());
            for (SSLCertificate cert : expiredCerts) {
                logger.error("  - [已过期] {}", cert);
            }
        }
        
        // 总结
        List<SSLCertificate> allNeedingRenewal = sslService.checkCertificatesNeedingRenewal();
        if (CollUtil.isEmpty(allNeedingRenewal)) {
            logger.info("所有证书状态正常，无需续期");
        } else {
            logger.warn("共有{}个证书需要续期", allNeedingRenewal.size());
        }
    }
    
    /**
     * 自动续期需要续期的证书（包括即将过期和已过期的）
     */
    private static void autoRenewCertificates(SSLCertificateService sslService) {
        logger.info("开始自动证书续期流程（包括即将过期和已过期的证书）...");
        sslService.autoRenewCertificatesNeedingRenewal();
    }
    
    /**
     * 列出所有证书
     */
    private static void listAllCertificates(SSLCertificateService sslService) {
        logger.info("获取所有SSL证书列表...");
        
        List<SSLCertificate> allCerts = sslService.getAllCertificates();
        
        if (CollUtil.isEmpty(allCerts)) {
            logger.info("没有找到任何SSL证书");
        } else {
            logger.info("共找到{}个SSL证书:", allCerts.size());
            for (SSLCertificate cert : allCerts) {
                logger.info("  - {}", cert);
            }
        }
    }
    
    /**
     * 打印帮助信息
     */
    private static void printHelp() {
        System.out.println("SSL证书自动管理工具");
        System.out.println("");
        System.out.println("用法:");
        System.out.println("  java -jar ssl-cert-manager.jar [选项] [操作]");
        System.out.println("");
        System.out.println("选项:");
        System.out.println("  -c, --config <文件>    指定配置文件路径 (默认: ssl-config.json)");
        System.out.println("  -a, --action <操作>    指定执行的操作");
        System.out.println("");
        System.out.println("操作:");
        System.out.println("  check        检查即将到期的证书");
        System.out.println("  check-expired 检查已过期的证书");
        System.out.println("  check-all    检查所有证书状态（包括即将过期和已过期）");
        System.out.println("  auto         自动续期所有需要续期的证书 (默认)");
        System.out.println("  list         列出所有证书");
        System.out.println("  help         显示帮助信息");
        System.out.println("");
        System.out.println("示例:");
        System.out.println("  java -jar ssl-cert-manager.jar check");
        System.out.println("  java -jar ssl-cert-manager.jar check-expired");
        System.out.println("  java -jar ssl-cert-manager.jar check-all");
        System.out.println("  java -jar ssl-cert-manager.jar -c my-config.json auto");
        System.out.println("  java -jar ssl-cert-manager.jar list");
    }
}